# 1、密码验证
# 2、列表去重并从大到小排序
# 3、如果在一个函数内部修改全局变量
# 4、如何跨模块共享全局变量
# 5、python数据类型有哪些
# 6、python中生成随机整数（1-10），随机小数（1-10），0-1之间小数的方法
# 7、python2与python3 的区别，列出5个
# 8、python中哪些是可变数据类型，哪些是不可变数据类型，为什么
# 9、统计字符串中每个单词出现的次数
# 10、给定一个字符串，找到字符串中第一个重复的字符
# 11、设么是pep8
# 12、python里如何赋值，深拷贝与浅拷贝的区别
# 13、简述python的内存管理机制
# 14、使用python实现冒泡排序
# 15、使用python实现快速排序
# 16、输出九九乘法表
# 17、重复接受用户的数据，如果是正整数就输出结果，否则一直输入
# 18、有两个列表[11,-3,4,5,2,1,8] , [9,3,4,2,6,-10] 把它们合并成一个列表，并且从小到大排序

# 1、密码验证
# 长度超过8位
# 包括大、小写字母、数字、其他字符，以上四种至少三种
# 不能有长度超过或等于3的字串
# 密码的等级，默认为2分，以上条件满足一条加一份
# 返回密码等级以及需要改进的点：return 3["长度小于8，密码没有由3种以上字符组成"]


# # 判断密码长度是否超过8
# def passwd_qiangdu1(passwd: str, grade):
#     if len(passwd) <= 8:
#         advice.append("你的密码长度没有超过8")
#     else:
#         grade += 1
#     return grade
#
#
# #判断是否有大小写、数字、其他字符
# result=[0,0,0,0]
# def passwd_qiangdu2(passwd:str):
#     for i in passwd:
#         if sum(result)>=3:
#             break
#         else:
#             if i.isdigit():
#                 result[0] = 1
#             elif i.isupper():
#                 result[1] = 1
#             elif i.islower():
#                 result[2] = 1
#             else:
#                 result[3] = 1
#     return result
#
# #
# # 不能有长度超过或等于3的子串
# def passwd_qiangdu3():
#     for i in range(len(passwd)):
#         if passwd.count(passwd[i:i + 3]) >=2:
#             advice.append("你的密码长度超过或等于3的子串重复")
#             return 0
#         else:
#             return 1
#
#
# passwd = input("请输入密码:")
# grade = 2
# advice = []
# grade = passwd_qiangdu1(passwd, grade)
# grade1 = passwd_qiangdu3()
# if grade1 == 1:
#    grade+=1
# result1 = passwd_qiangdu2(passwd)
# if sum(result1)<3:
#     info=["你的密码需要大小写、数字、其他字母，以上4种至少需要3种"]
#     print(grade,advice+info)
# else:
#     grade+=1
#     print(grade, advice)

#2、列表去重并从大到小排序
# a=[10,3,8,6,7,6,7,3,4,10,1,2]
# a_set= list(set(a))
# a_set.sort()
# print(a_set)
# a_set.sort(reverse=True)
# print(a_set)

#3、如何在一个函数内部修改全局变量 -----加入global关键字
# a=100
# # def tx():
# #     a=200
# #     print(a)
# # tx()
# # print(a)
#
# def tx():
#     global a
#     a=200
#     print(a)
# tx()
# print(a)

#4、如何跨模块共享全局变量****

#5、python数据类型有哪些
#1、文本类型  str
#2、数值类型  int float complex
#3、序列类型  list tuple range
#4、映射类型 dict
#5、集合类型  set frozenset
#6、布尔类型 bool
#7、二进制类型  bytes
#type()函数获取数据类型

#6、python中生成随机整数（1-10），随机小数（1-10），0-1之间小数的方法
# import random
# for i in range(1,11):
#     num=random.randint(i,10)
#     print(num)
#     num1=random.uniform(i,10)
#     print(round(num1,4))
#     num2=random.uniform(0,1)
#     print(round(num2,2))

#7、python2与python3 的区别，列出5个
#输出有区别
#编码区别
#除法有区别(python2是地板除)
#python3中都是字符串类型，python2中有整数类型
#异常处理的语法不一样
#xrange pyhton3中没有xrange,range就是python2中的xrange

#8、python中哪些是可变数据类型，哪些是不可变数据类型，为什么
#可变数据类型：list,dict,set
#不可变数据类型：str bool int float tuple
#由于python属于解释型语言，即出现变量赋值就会开辟相应的内存空间。不可变数据类型在在第一次赋值时，内存会给予相应的空间存储这个变量的赋予的值，
# 而这个存储空间就是内存中的一个地址，而变量所存放的并不是赋予的值，而是这个内存地址，通过这个地址变量便可以从这个地址中取出数据。不可变就是
# 说我们不能改变这个数据在内存中的值，所以重新赋值时，我们只是新开辟了一块空间，将新的数据存放在新的空间，而原来的那个变量不会再引用原数据的
# 内存地址而转换为新的内存地址。
#可变数据类型可以对内存中的数据进行修改，并不会导致变量引用地址的变化，但这种修改权限仅仅在于python中的内置方法。当如果要进行重新赋值，
# 一样会改变变量的地址指向。当变量指向新的内存后，那么之前的内存就会被收回。

#9、统计字符串中每个单词出现的次数
# str=input("请输入你所想要的字符串:")
# for i in str:
#     b=str.count(i)
#     print(f"{i}=",b)

#10、给定一个字符串，找到字符串中第一个重复的字符
# str1="aaadfgf"
# lit = []
# num = []
# for i in range(len(str1)):
#     str2 = []
#     if str1.count(str1[i]) > 1:
#         if str1[i] in lit:
#             continue
#         else:
#             lit.append(str1[i])
#         str2 = str1[0:i]+str1[i+1:]
#         print(str2)
#         b = str2.find(str1[i])
#         print(b)
#         num.append(b+1)
#
# num.sort()
# print(num)
# print(str1[num[0]])

#11、什么是pep8
#编码规范
#1、代码编排：
#(1) 缩进。4个空格的缩进（编辑器都可以完成此功能），不使用Tap，更不能混合使用Tap和空格。
# (2) 每行最大长度79，换行可以使用反斜杠，最好使用圆括号。换行点要在操作符的后边敲回车。
# (3) 类和top-level函数定义之间空两行；类中的方法定义之间空一行；函数内逻辑无关段落之间空一行；其他地方尽量不要再空行。
#2、文档编排
#3、空格的使用
#4、注释
#5、文档描述
#6、命名规范
#7、编码建议

#12、python里如何赋值，深拷贝与浅拷贝的区别
#直接赋值  copy  deepcopy
#浅拷贝有两个独立的对象，但指向的子对象是统一的。-----拷贝第一层数据(地址)
#深拷贝完全拷贝了父对象及其子对象，两者完全独立。-----递归拷贝所以层的数据

#13、简述python的内存管理机制
#python的内存管理机制分为三种，引用机制、垃圾回收机制、Python缓冲池。
#引用机制：在Python中，每个对象都有指向该对象的引用总数---引用计数
         # 查看对象的引用计数：sys.getrefcount()
         #  当有新的引用指向的时候，引用计数加1
         #  当有无效的引用发生时，引用计数减少1
         #  当对象的引用计数为0时，销毁对象
#垃圾回收机制：分代回收----python gc给对象定义了三代，每一个新生对象都会放在第0代，在某一代时分配的对象与被释放的对象之差达到一定阈值，就会触发gc
#对一代的扫描，经过一次一次的扫描，新生对象会从第0代移动到第一代，甚至第2代，前提是能够存活下来。
#           标记清除 ---主要用于解决循环引用
#缓冲池：整数对象缓冲池  范围在[-5,256]
#        字符串驻留区  含有特殊字符串的不会放在驻留区

#16、输出九九乘法表
# for i in range(1,10):
#     for j in range(1,i+1):
#         print(f"{i}*{j}={i*j}",end="\t")
#     print()

#17、重复接受用户的数据，如果是正整数就输出结果，否则一直输入
# while True:
#     num = input("请输入你的数据:")
#     if int(num)>0:
#             print("你的输入正确")
#             break
#     else:
#         print("你的输入错误")
#         continue

#18、有两个列表[11,-3,4,5,2,1,8] , [9,3,4,2,6,-10] 把它们合并成一个列表，并且从小到大排序
# lst1=[11,-3,4,5,2,1,8]
# lst2=[9,3,4,2,6,-10]
# lst3=lst1+lst2
# lst3.sort()
# print(lst3)

#19、a+=1 与 a=a+1 有什么区别
#a+=1-----对于不可变类型，进行操作后，内存地址就发生了变化，生成了新的对象；而对于可变类型，都是在原对象上操作
#a=a+1 ----是指变量a加上1再赋值给变量a----相当于生成了一个新的对象，但这个对象还是叫a,此时内存地址已经发生变化


# 14、使用python实现冒泡排序
# def bubblesort(data):
#    for i in range(len(data)):
#        for j in range(len(data)-i-1):
#           if data[j]>data[j+1]:
#               data[j],data[j+1]=data[j+1],data[j]
#
# data=[10,3,11,23,5,7,9,15,19,4,6]
# bubblesort(data)
# print("排序后的数组:")
# for i in range(len(data)):
#     print(data[i])

# 15、使用python实现快速排序
# def partition(arr,low,high):
#     # 最小元素索引
#     i = (low-1)
#     #基准值
#     pivot = arr[high]
#     for j in range(low,high):
#         #当前元素小于等于基准值
#         if arr[j]<=pivot:
#             i+=1
#             arr[i],arr[j] = arr[j],arr[i]
#     arr[i+1],arr[high] = arr[high],arr[i+1]
#     return (i+1)
#
# def quicksort(arr,low,high):
#     if low < high:
#         pi = partition(arr,low,high)
#         quicksort(arr,low,pi-1)
#         quicksort(arr,pi+1,high)
#
#
# arr = [10,8,11,7,1,6,5,12,13]
# n=len(arr)
# quicksort(arr,0,n-1)
# print("排序后的数组:")
# for i in range(n):
#     print(arr[i])
#
